RACOFI: A Rule-Applying Collaborative Filtering System

In this paper we give an overview of the RACOFI (Rule-Applying Collaborative Filtering) multidimensional rating system and its related technologies. This will be exemplified with RACOFI Music, an implemented collaboration agent that assists on-line users in the rating and recommendation of audio (Learning) Objects. It lets users rate contemporary Canadian music in the five dimensions of impression, lyrics, music, originality, and production. The collaborative filtering algorithms STI Pearson, STIN2, and the Per Item Average algorithms are then employed together with RuleML-based rules to recommend music objects that best match user queries. RACOFI has been on-line since August 2003 at http://racofi.elg.ca.

A direct semantic characterization of RELFUN

This paper attempts a direct semantic formalization of first-order relational-functional languages (the characteristic RELFUN subset) in terms of a generalized model concept. Function-defining conditional equations (or, footed clauses) and active call-by-value expressions (in clause premises) are integrated into first-order theories. Herbrand models are accommodated to relational-functional programs by not only containing ground atoms but also ground molecules, i.e. specific function applications paired with values. Extending SLD-resolution toward innermost conditional narrowing of relational-functional clauses, SLV-resolution is introduced, which, e.g., flattens active expressions. The Tp-operator is generalized analogously, e.g. by unnesting ground-clause premises. Soundness and completeness proofs for SLV-resolution naturally extend the corresponding results in logic programming

Extended logic-plus-functional programming

Extensions of logic and functional programming are integrated in RELFUN. Its valued clauses comprise Horn clauses (true\u27-valued) and clauses with a distinguished foot\u27 premise (returning arbitrary values). Both the logic and functional components permit LISP-like varying-arity and higher-order operators. The DATAFUN sublanguage of the functional component is shown to be preferable to relational encodings of functions in DATALOG. RELFUN permits non-ground, non-deterministic functions, hence certain functions can be inverted using an is\u27-primitive generalizing that of PROLOG. For function nestings a strict call-by-value strategy is employed. The reduction of these extensions to a relational sublanguage is discussed and their WAM compilation is sketched. Three examples (serialise\u27, wang\u27, and eval\u27) demonstrate the relational/functional style in use. The list expressions of RELFUN\u27s LISP implementation are presented in an extended PROLOG-like syntax

Declarative operations on nets

To increase the expressiveness of knowledge representations, the graph-theoretical basis of semantic networks is reconsidered. Directed labeled graphs are generalized to directed recursive labelnode hypergraphs, which permit a most natural representation of multi-level structures and n-ary relationships. This net formalism is embedded into the relational/functional programming language RELFUN. Operations on (generalized) graphs are specified in a declarative fashion to enhance readability and maintainability. For this, nets are represented as nested RELFUN terms kept in a normal form by rules associated directly with their constructors. These rules rely on equational axioms postulated in the formal definition of the generalized graphs as a constructor algebra. Certain kinds of sharing in net diagrams are mirrored by binding common subterms to logical variables. A package of declarative transformations on net terms is developed. It includes generalized set operations, structure-reducing operations, and extended path searching. The generation of parts lists is given as an application in mechanical engineering. Finally, imperative net storage and retrieval operations are discussed

Finite domains and exclusions as first-class citizens

Languages based on logical variables can regard finite domains, finite exclusions, and, generally, types as values. Like a variable can be bound to a non-ground structure which can be later specialized through in-place assignment of some inner variables, it can also be bound to, say, a domain structure which can be specialized later through "in-place deletion" of some of its elements (e.g. by intersection with other domain structures). While finite domains prescribe the elements of a disjunctive structure, the complementary finite exclusions forbid the elements of a conjunctive structure. Domains and exclusions can be values of variables or occur inside clauses as/in terms or within an occurrence-binding construct (useful to name arbitrary terms).In a relational-functional language (e.g., RELFUN) they can also be returned as values of functions. Altogether, domains and exclusions become first-class citizens. Because they are completely handled by an extended unification routine, they do not require delay techniques needed in (more expressive) constraint systems. Still, their backtracking-superseding "closed" representation leads to smaller proof trees (efficiency), and abstracted, intensional answers (readability). Anti-unification (for generalization) exchanges the roles of domains and exclusions. The operational semantics of domains, exclusions, and occurrence bindings is specified by a RELFUN meta-unify function (and implemented in pure LISP)

A treatment of collection data as constructor algebras

This paper gives algebraic definitions of various types of nested variable-length “collections” of elements, usable as data structures. First of all, however, the paper introduces constructor algebras through an integer sequences data type. It then begins with the fundamental CONS algebra of N-tuples and a variant with “negative" elements, complementing it and subsequent homogeneous algebras by heterogeneous ones. For such list algebras, the paper postulates axioms embodying the three “basic properties“ [Commutativity‚ Idempotence, Associativity], and uses these to define the remaining seven "basic collections" [strings‚ communes, acommunes, bags, abags, sets, heaps]. Proceeding to ”non-basic collections", it then introduces "adsorption" properties [”complementary" to absorption], which are characteristic for graphs, and postulates them as axioms in algebras of ordinary graphs and of directed recursive labelnode hypergraphs [DRLHs]. Finally, it defines the property of "Similpotence" [“weaker” than Idempotence] and postulates it for DRLHs with contact labelnodes, as applied in knowledge representation

Expert-System Shells : Very-High-Level Languages for Artificial Intelligence

Expert-system shells are discussed as very-high-level programming languages for knowledge engineering. Based on a category/domain distinction for expert systems the concept of expert-system shells is explained using seven classifications. A proposal for a shell-development policy is sketched. The conclusions express concern about overemphasis on shell surfaces

FIT-PROLOG : a functional/relational language comparison

The programming languages FIT and PROLOG are compared as examples of functional and relational programming, respectively. This leads to some proposals concerning both languages. As an introductory tutorial, PROLOG facts, questions, variables, conjunctions, and rules are reformulated in FIT. A natural equivalence between functions and relations is exploited for their interchangeable FIT use. An ESCVAL operator is proposed which causes relation calls to return values of request variables and thus permits their function-like nesting. Function calls with request variables are introduced, showing a sense in which FIT functions are more general than PROLOG relations. Higher-order functions and relations are demonstrated to be available in FIT but not in PROLOG. PROLOG structures and FIT compounds differ mainly in the fixed arity of the former and the variable length of the latter. FIT's compounds can also be interpreted as function calls that return themselves in normalized form. Pattern matching in PROLOG [FIT] treats list heads and tails asymmetrically [symmetrically] and doesn't [does] allow for non-deterministic results. While PROLOG generalizes pattern-data matching to pattern-pattern unification. FIT generalizes it to adapter-data fitting. PROLOG's Horn clauses in FIT become implicit fitters: Facts become special implicit adapters and rules become special implicit transformers; for PROLOG II constraints, transformers with LOCAL bodies or invocation adapters with COM[POSE-TRA]FO expressions can be used. While PROLOG interprets clauses in textual order, FIT interprets them in a specificity order which is modifiable by a SECURE operator. Although PROLOG's cut operator is not used in FIT, a proposal is made to distinguish the specification of clause ordering [by FIT's SECURE operator] and the specification of clause abandoning [by an EXCLUSIVE operator corresponding to 'initial'-restricted cuts]. EXCLUSIVE-marked COMFO-constrained rules are then used for functional and relational representations of guarded commands. A comparison of the list processing capabilities of both languages exemplifies how FIT's adapters can make relational programming more concise than PROLOG’s Horn clauses. The representation of sets as lists without duplicates leads to difficulties with PROLOG's standard intersection and union predicates, which can be overcome by representing them as the self-normalizing CLASS data structure in FIT. Possible reasons for the poor readability of Warren's PROLOG serialise predicate are discussed and an alternative FIT function is formulated which shows the inherent simplicity of this problem. McDermott's PROLOG quadrat predicate is transformed into a more concise and readable ESCVAL form, which in turn is transformed into a corresponding FIT ESCVAL form and into a functional FIT form. Fermat's equation is formulated relationally, showing that for principal reasons some relations can not be used in all ways allowed by PROLOG's notation, a problem that does not arise in a corresponding functional FIT formulation